home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gdevxalt.c < prev    next >
C/C++ Source or Header  |  1997-05-21  |  17KB  |  611 lines
  1. /* Copyright (C) 1994, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevxalt.c */
  20. /* Alternative X Windows drivers for help in driver debugging */
  21. #include "gx.h"            /* for gx_bitmap; includes std.h */
  22. #include "math_.h"
  23. #include "memory_.h"
  24. #include "x_.h"
  25. #include "gserrors.h"
  26. #include "gsparam.h"
  27. #include "gxdevice.h"
  28. #include "gdevx.h"
  29.  
  30. extern gx_device_X gs_x11_device;
  31.  
  32. /* ---------------- Generic procedures ---------------- */
  33.  
  34. /* Forward declarations */
  35. private int get_dev_target(P2(gx_device **, gx_device *));
  36. #define set_dev_target(tdev, dev)\
  37.   do {\
  38.     int code_ = get_dev_target(&tdev, dev);\
  39.     if ( code_ < 0 )\
  40.       return code_;\
  41.   } while (0)
  42. private int get_target_info(P1(gx_device *));
  43. private gx_color_index x_alt_map_color(P2(gx_device *, gx_color_index));
  44.  
  45. /* "Wrappers" for driver procedures */
  46.  
  47. private int
  48. x_wrap_open(gx_device *dev)
  49. {    gx_device *tdev;
  50.     int rcode, code;
  51.  
  52.     set_dev_target(tdev, dev);
  53.     rcode = (*dev_proc(tdev, open_device))(tdev);
  54.     if ( rcode < 0 )
  55.       return rcode;
  56.     tdev->is_open = true;
  57.     code = get_target_info(dev);
  58.     return (code < 0 ? code : rcode);
  59. }
  60.  
  61. private int
  62. x_forward_sync_output(gx_device *dev)
  63. {    gx_device *tdev;
  64.  
  65.     set_dev_target(tdev, dev);
  66.     return (*dev_proc(tdev, sync_output))(tdev);
  67. }
  68.  
  69. private int
  70. x_forward_output_page(gx_device *dev, int num_copies, int flush)
  71. {    gx_device *tdev;
  72.  
  73.     set_dev_target(tdev, dev);
  74.     return (*dev_proc(tdev, output_page))(tdev, num_copies, flush);
  75. }
  76.  
  77. private int
  78. x_wrap_close(gx_device *dev)
  79. {    gx_device *tdev;
  80.     /* If Ghostscript is exiting, we might have closed the */
  81.     /* underlying x11 device already.... */
  82.     int code;
  83.  
  84.     set_dev_target(tdev, dev);
  85.     if ( tdev->is_open )
  86.       {    code = (*dev_proc(tdev, close_device))(tdev);
  87.         if ( code < 0 )
  88.           return code;
  89.         tdev->is_open = false;
  90.       }
  91.     else
  92.       code = 0;
  93.     return code;
  94. }
  95.  
  96. private int
  97. x_wrap_map_color_rgb(gx_device *dev, gx_color_index color,
  98.   gx_color_value prgb[3])
  99. {    gx_device *tdev;
  100.  
  101.     set_dev_target(tdev, dev);
  102.     return (*dev_proc(tdev, map_color_rgb))(tdev,
  103.                         x_alt_map_color(dev, color),
  104.                         prgb);
  105. }
  106.  
  107. private int
  108. x_wrap_fill_rectangle(gx_device *dev, int x, int y, int w, int h,
  109.   gx_color_index color)
  110. {    gx_device *tdev;
  111.  
  112.     set_dev_target(tdev, dev);
  113.     return (*dev_proc(tdev, fill_rectangle))(tdev, x, y, w, h,
  114.                          x_alt_map_color(dev, color));
  115. }
  116.  
  117. private int
  118. x_wrap_copy_mono(gx_device *dev,
  119.   const byte *base, int sourcex, int raster, gx_bitmap_id id,
  120.   int x, int y, int w, int h,
  121.   gx_color_index zero, gx_color_index one)
  122. {    gx_device *tdev;
  123.  
  124.     set_dev_target(tdev, dev);
  125.     return (*dev_proc(tdev, copy_mono))(tdev, base, sourcex, raster, id,
  126.                         x, y, w, h,
  127.                         x_alt_map_color(dev, zero),
  128.                         x_alt_map_color(dev, one));
  129.  
  130. }
  131.  
  132. private int
  133. x_forward_copy_color(gx_device *dev, const byte *base, int sourcex,
  134.              int raster, gx_bitmap_id id, int x, int y, int w, int h)
  135. {    gx_device *tdev;
  136.  
  137.     set_dev_target(tdev, dev);
  138.     return (*dev_proc(tdev, copy_color))(tdev, base, sourcex, raster, id,
  139.                          x, y, w, h);
  140. }
  141.  
  142. private int
  143. x_forward_get_bits(gx_device *dev, int y, byte *str, byte **actual_data)
  144. {    gx_device *tdev;
  145.  
  146.     set_dev_target(tdev, dev);
  147.     return (*dev_proc(tdev, get_bits))(tdev, y, str, actual_data);
  148. }
  149.  
  150. private int
  151. x_wrap_get_bits(gx_device *dev, int y, byte *str, byte **actual_data)
  152. {    int depth = dev->color_info.depth;
  153.     gx_device *tdev;
  154.     int width;
  155.     int sdepth;
  156.     byte smask;
  157.     uint dsize;
  158.     gs_memory_t *mem =
  159.       (dev->memory == 0 ? &gs_memory_default : dev->memory);
  160.     byte *row;
  161.     byte *base;
  162.     int code;
  163.     gx_color_index pixel_in = gx_no_color_index;
  164.     gx_color_index pixel_out;
  165.     int xi;
  166.     int sbit;
  167.     declare_line_accum(str, depth, 0);
  168.  
  169.     set_dev_target(tdev, dev);
  170.     width = tdev->width;
  171.     sdepth = tdev->color_info.depth;
  172.     smask = (sdepth <= 8 ? (1 << sdepth) - 1 : 0xff);
  173.     dsize = (width * sdepth + 7) / 8;
  174.     row = gs_alloc_bytes(mem, dsize, "x_wrap_get_bits");
  175.     if ( row == 0 )
  176.       return_error(gs_error_VMerror);
  177.     code = (*dev_proc(tdev, get_bits))(tdev, y, row, &base);
  178.     if ( code < 0 )
  179.       goto gx;
  180.     for ( sbit = 0, xi = 0; xi < width; sbit += sdepth, ++xi )
  181.       {    const byte *sptr = base + (sbit >> 3);
  182.         gx_color_index pixel;
  183.         gx_color_value rgb[3];
  184.         int i;
  185.  
  186.         if ( sdepth <= 8 )
  187.           pixel = (*sptr >> (8 - sdepth - (sbit & 7))) & smask;
  188.         else
  189.           { pixel = 0;
  190.             for ( i = 0; i < depth; i += 8, ++sptr )
  191.               pixel = (pixel << 8) + *sptr;
  192.           }
  193.         if ( pixel != pixel_in )
  194.           { (*dev_proc(tdev, map_color_rgb))(tdev, pixel, rgb);
  195.             pixel_in = pixel;
  196.             pixel_out = (*dev_proc(dev, map_rgb_color))(dev, rgb[0], rgb[1], rgb[2]);
  197.           }
  198.         line_accum(pixel_out, depth);
  199.       }
  200.     line_accum_store(depth);
  201. gx:    gs_free_object(mem, row, "x_wrap_get_bits");
  202.     *actual_data = str;
  203.     return code;
  204. }
  205.  
  206. private int
  207. x_wrap_get_params(gx_device *dev, gs_param_list *plist)
  208. {    gx_device *tdev;
  209.     /* We assume that a get_params call has no side effects.... */
  210.     gx_device_X save_dev;
  211.     int code;
  212.  
  213.     set_dev_target(tdev, dev);
  214.     save_dev = *(gx_device_X *)tdev;
  215.     if ( tdev->is_open )
  216.       tdev->color_info = dev->color_info;
  217.     tdev->dname = dev->dname;
  218.     code = (*dev_proc(tdev, get_params))(tdev, plist);
  219.     *(gx_device_X *)tdev = save_dev;
  220.     return code;
  221. }
  222.  
  223. private int
  224. x_wrap_put_params(gx_device *dev, gs_param_list *plist)
  225. {    gx_device *tdev;
  226.     int rcode, code;
  227.  
  228.     set_dev_target(tdev, dev);
  229.     rcode = (*dev_proc(tdev, put_params))(tdev, plist);
  230.     if ( rcode < 0 )
  231.       return rcode;
  232.     code = get_target_info(dev);
  233.     return (code < 0 ? code : rcode);
  234. }
  235.  
  236. /* Internal procedures */
  237.  
  238. /* Get the target, creating it if necessary. */
  239. private int
  240. get_dev_target(gx_device **ptdev, gx_device *dev)
  241. {    gx_device *tdev = ((gx_device_forward *)dev)->target;
  242.  
  243.     if ( tdev == 0 )
  244.       {    /* Create or link to an X device instance. */
  245.         if ( dev->memory == 0 )    /* static instance */
  246.           tdev = (gx_device *)&gs_x11_device;
  247.         else
  248.           {    tdev = (gx_device *)gs_alloc_bytes(dev->memory,
  249.                         (gs_x11_device).params_size,
  250.                         "dev_target");
  251.             if ( tdev == 0 )
  252.               return_error(gs_error_VMerror);
  253.             *(gx_device_X *)tdev = gs_x11_device;
  254.             tdev->memory = dev->memory;
  255.             tdev->is_open = false;
  256.           }
  257.         gx_device_fill_in_procs(tdev);
  258.         ((gx_device_forward *)dev)->target = tdev;
  259.       }
  260.     *ptdev = tdev;
  261.     return 0;
  262. }
  263.  
  264. /* Copy parameters back from the target. */
  265. private int
  266. get_target_info(gx_device *dev)
  267. {    gx_device *tdev;
  268.  
  269.     set_dev_target(tdev, dev);
  270.  
  271. #define copy(m) dev->m = tdev->m;
  272. #define copy2(m) copy(m[0]); copy(m[1])
  273. #define copy4(m) copy2(m); copy(m[2]); copy(m[3])
  274.  
  275.     copy(width); copy(height);
  276.     copy2(MediaSize);
  277.     copy4(ImagingBBox);
  278.     copy(ImagingBBox_set);
  279.     copy2(HWResolution);
  280.     copy2(MarginsHWResolution);
  281.     copy2(Margins);
  282.     copy4(HWMargins);
  283.     if ( dev->color_info.num_components == 3 )
  284.       copy(color_info);
  285.  
  286. #undef copy4
  287. #undef copy2
  288. #undef copy
  289.  
  290.     return 0;
  291. }
  292.  
  293. /* Map a fake CMYK or black/white color to a real X color if necessary. */
  294. private gx_color_index
  295. x_alt_map_color(gx_device *dev, gx_color_index color)
  296. {    gx_device *tdev;
  297.     gx_color_value r, g, b;
  298.  
  299.     if ( color == gx_no_color_index )
  300.       return color;
  301.     set_dev_target(tdev, dev);
  302.     switch ( dev->color_info.num_components )
  303.       {
  304.       case 3:    /* RGB, this is the real thing (possibly + alpha) */
  305.         return color & 0xffffff;
  306.       case 4:    /* CMYK */
  307.         if ( color & 1 )
  308.           r = g = b = 0;
  309.         else
  310.           { r = (color & 8 ? 0 : gx_max_color_value);
  311.         g = (color & 4 ? 0 : gx_max_color_value);
  312.         b = (color & 2 ? 0 : gx_max_color_value);
  313.           }
  314.         break;
  315.       default /*case 1*/:
  316.         if ( dev->color_info.depth == 1 )
  317.           {     /* 0 = white, 1 = black */
  318.         r = g = b = (color ? 0 : gx_max_color_value);
  319.           }
  320.         else
  321.           { r = g = b =
  322.           color * gx_max_color_value / dev->color_info.max_gray;
  323.           }
  324.         break;
  325.       }
  326.     return (*dev_proc(tdev, map_rgb_color))(tdev, r, g, b);
  327. }
  328.  
  329. /* ---------------- CMYK procedures ---------------- */
  330.  
  331. /* Device procedures */
  332. private dev_proc_map_rgb_color(x_cmyk_map_rgb_color);
  333. private dev_proc_map_cmyk_color(x_cmyk_map_cmyk_color);
  334.  
  335. /* The device descriptor */
  336. private gx_device_procs x_cmyk_procs = {
  337.     x_wrap_open,
  338.     gx_forward_get_initial_matrix,
  339.     x_forward_sync_output,
  340.     x_forward_output_page,
  341.     x_wrap_close,
  342.     x_cmyk_map_rgb_color,
  343.     x_wrap_map_color_rgb,
  344.     x_wrap_fill_rectangle,
  345.     gx_default_tile_rectangle,
  346.     x_wrap_copy_mono,
  347.     gx_default_copy_color,        /* do it the slow, painful way */
  348.     gx_default_draw_line,
  349.     x_wrap_get_bits,
  350.     x_wrap_get_params,
  351.     x_wrap_put_params,
  352.     x_cmyk_map_cmyk_color,
  353.     gx_forward_get_xfont_procs,
  354.     gx_forward_get_xfont_device,
  355.     NULL,            /* map_rgb_alpha_color */
  356.     gx_forward_get_page_device,
  357.     gx_forward_get_alpha_bits,
  358.     NULL            /* copy_alpha */
  359. };
  360.  
  361. /* The instance is public. */
  362. gx_device_forward far_data gs_x11cmyk_device = {
  363.     std_device_dci_body(gx_device_forward, &x_cmyk_procs, "x11cmyk",
  364.       FAKE_RES*85/10, FAKE_RES*11,    /* x and y extent (nominal) */
  365.       FAKE_RES, FAKE_RES,    /* x and y density (nominal) */
  366.       4, 4, 1, 1, 2, 2),
  367.     { 0 },            /* std_procs */
  368.     0            /* target */
  369. };
  370.  
  371. /* Device procedures */
  372.  
  373. private gx_color_index
  374. x_cmyk_map_rgb_color(gx_device *dev,
  375.   gx_color_value r, gx_color_value g, gx_color_value b)
  376. {    /* This should never be called! */
  377.     return gx_no_color_index;
  378. }
  379.  
  380. private gx_color_index
  381. x_cmyk_map_cmyk_color(gx_device *dev,
  382.   gx_color_value c, gx_color_value m, gx_color_value y,
  383.   gx_color_value k)
  384. {    return
  385.       (gx_color_index)
  386.         (((c >> (gx_color_value_bits - 4)) & 8) |
  387.          ((m >> (gx_color_value_bits - 3)) & 4) |
  388.          ((y >> (gx_color_value_bits - 2)) & 2) |
  389.          ((k >> (gx_color_value_bits - 1)) & 1));
  390. }
  391.  
  392. /* ---------------- Black-and-white procedures ---------------- */
  393.  
  394. /* The device descriptor */
  395. private gx_device_procs x_mono_procs = {
  396.     x_wrap_open,
  397.     gx_forward_get_initial_matrix,
  398.     x_forward_sync_output,
  399.     x_forward_output_page,
  400.     x_wrap_close,
  401.     gx_default_b_w_map_rgb_color,
  402.     x_wrap_map_color_rgb,
  403.     x_wrap_fill_rectangle,
  404.     gx_default_tile_rectangle,
  405.     x_wrap_copy_mono,
  406.     gx_default_copy_color,
  407.     gx_default_draw_line,
  408.     x_wrap_get_bits,
  409.     x_wrap_get_params,
  410.     x_wrap_put_params,
  411.     gx_default_map_cmyk_color,
  412.     gx_forward_get_xfont_procs,
  413.     gx_forward_get_xfont_device,
  414.     NULL,            /* map_rgb_alpha_color */
  415.     gx_forward_get_page_device,
  416.     gx_forward_get_alpha_bits,
  417.     NULL            /* copy_alpha */
  418. };
  419.  
  420. /* The instance is public. */
  421. gx_device_forward far_data gs_x11mono_device = {
  422.     std_device_dci_body(gx_device_forward, &x_mono_procs, "x11mono",
  423.       FAKE_RES*85/10, FAKE_RES*11,    /* x and y extent (nominal) */
  424.       FAKE_RES, FAKE_RES,    /* x and y density (nominal) */
  425.       1, 1, 1, 0, 2, 0),
  426.     { 0 },            /* std_procs */
  427.     0            /* target */
  428. };
  429.  
  430. /* ---------------- 2-bit gray-scale procedures ---------------- */
  431.  
  432. /* The device descriptor */
  433. private gx_device_procs x_gray2_procs = {
  434.     x_wrap_open,
  435.     gx_forward_get_initial_matrix,
  436.     x_forward_sync_output,
  437.     x_forward_output_page,
  438.     x_wrap_close,
  439.     gx_default_gray_map_rgb_color,
  440.     x_wrap_map_color_rgb,
  441.     x_wrap_fill_rectangle,
  442.     gx_default_tile_rectangle,
  443.     x_wrap_copy_mono,
  444.     gx_default_copy_color,
  445.     gx_default_draw_line,
  446.     x_wrap_get_bits,
  447.     x_wrap_get_params,
  448.     x_wrap_put_params,
  449.     gx_default_map_cmyk_color,
  450.     gx_forward_get_xfont_procs,
  451.     gx_forward_get_xfont_device,
  452.     NULL,            /* map_rgb_alpha_color */
  453.     gx_forward_get_page_device,
  454.     gx_forward_get_alpha_bits,
  455.     NULL            /* copy_alpha */
  456. };
  457.  
  458. /* The instance is public. */
  459. gx_device_forward far_data gs_x11gray2_device = {
  460.     std_device_dci_body(gx_device_forward, &x_gray2_procs, "x11gray2",
  461.       FAKE_RES*85/10, FAKE_RES*11,    /* x and y extent (nominal) */
  462.       FAKE_RES, FAKE_RES,    /* x and y density (nominal) */
  463.       1, 2, 3, 0, 4, 0),
  464.     { 0 },            /* std_procs */
  465.     0            /* target */
  466. };
  467.  
  468. /* ---------------- Alpha procedures ---------------- */
  469.  
  470. /* Device procedures */
  471. private dev_proc_map_color_rgb(x_alpha_map_color_rgb);
  472. private dev_proc_map_rgb_alpha_color(x_alpha_map_rgb_alpha_color);
  473. private dev_proc_get_alpha_bits(x_alpha_get_alpha_bits);
  474. private dev_proc_copy_alpha(x_alpha_copy_alpha);
  475.  
  476. /* The device descriptor */
  477. private gx_device_procs x_alpha_procs = {
  478.     x_wrap_open,
  479.     gx_forward_get_initial_matrix,
  480.     x_forward_sync_output,
  481.     x_forward_output_page,
  482.     x_wrap_close,
  483.     gx_forward_map_rgb_color,
  484.     x_alpha_map_color_rgb,
  485.     x_wrap_fill_rectangle,
  486.     gx_default_tile_rectangle,
  487.     x_wrap_copy_mono,
  488.     x_forward_copy_color,
  489.     gx_default_draw_line,
  490.     x_forward_get_bits,
  491.     x_wrap_get_params,
  492.     x_wrap_put_params,
  493.     gx_forward_map_cmyk_color,
  494.     gx_forward_get_xfont_procs,
  495.     gx_forward_get_xfont_device,
  496.     x_alpha_map_rgb_alpha_color,
  497.     gx_forward_get_page_device,
  498.     x_alpha_get_alpha_bits,
  499.     /*gx_default_copy_alpha*/    x_alpha_copy_alpha
  500. };
  501.  
  502. /* The instance is public. */
  503. gx_device_forward far_data gs_x11alpha_device = {
  504.     std_device_dci_body(gx_device_forward, &x_alpha_procs, "x11alpha",
  505.       FAKE_RES*85/10, FAKE_RES*11,    /* x and y extent (nominal) */
  506.       FAKE_RES, FAKE_RES,    /* x and y density (nominal) */
  507.       3, 32, 255, 255, 256, 256),
  508.     { 0 },            /* std_procs */
  509.     0            /* target */
  510. };
  511.  
  512. /* Device procedures */
  513.  
  514. /* We encode a complemented alpha value in the top 8 bits of the */
  515. /* device color. */
  516. private int
  517. x_alpha_map_color_rgb(gx_device *dev, gx_color_index color,
  518.   gx_color_value prgb[3])
  519. {    return gx_forward_map_color_rgb(dev, color & 0xffffff, prgb);
  520. }
  521. private gx_color_index
  522. x_alpha_map_rgb_alpha_color(gx_device *dev,
  523.   gx_color_value r, gx_color_value g, gx_color_value b, gx_color_value alpha)
  524. {    gx_color_index color = gx_forward_map_rgb_color(dev, r, g, b);
  525.     byte abyte = alpha >> (gx_color_value_bits - 8);
  526.  
  527.     return (abyte == 0 ? 0xff000000 :
  528.         ((gx_color_index)(abyte ^ 0xff) << 24) + color);
  529. }
  530.  
  531. private int
  532. x_alpha_get_alpha_bits(gx_device *dev, graphics_object_type type)
  533. {    return 4;
  534. }
  535.  
  536. private int
  537. x_alpha_copy_alpha(gx_device *dev, const unsigned char *base, int sourcex,
  538.            int raster, gx_bitmap_id id, int x, int y, int w, int h,
  539.            gx_color_index color, int depth)
  540. {    gx_device *tdev;
  541.     int xi, yi;
  542.     const byte *row = base;
  543.     gx_color_index base_color = color & 0xffffff;
  544.     /* We fake alpha by interpreting it as saturation, i.e., */
  545.     /* alpha = 0 is white, alpha = 15/15 is the full color. */
  546.     gx_color_value rgb[3];
  547.     gx_color_index shades[16];
  548.     int i;
  549.  
  550. /**************** PATCH for measuring rasterizer speed ****************/
  551. /*if ( 1 ) return 0;*/
  552.  
  553.     set_dev_target(tdev, dev);
  554.     for ( i = 0; i < 15; ++i )
  555.       shades[i] = gx_no_color_index;
  556.     shades[15] = base_color;
  557.     (*dev_proc(tdev, map_color_rgb))(tdev, base_color, rgb);
  558.     /* Do the copy operation pixel-by-pixel. */
  559.     /* For the moment, if the base color has alpha in it, we ignore it. */
  560.     for ( yi = y; yi < y + h; row += raster, ++yi )
  561.       {    int prev_x = x;
  562.         gx_color_index prev_color = gx_no_color_index;
  563.         uint prev_alpha = 0x10;        /* not a possible value */
  564.  
  565.         for ( xi = x; xi < x + w; ++xi )
  566.           {    int sx = sourcex + xi - x;
  567.             uint alpha2 = row[sx >> 1];
  568.             uint alpha = (sx & 1 ? alpha2 & 0xf : alpha2 >> 4);
  569.             gx_color_index a_color;
  570.  
  571.             if ( alpha == prev_alpha )
  572.               continue;
  573.             prev_alpha = alpha;
  574.             if ( alpha == 0 )
  575.               a_color = gx_no_color_index;
  576.             else
  577.               while ( (a_color = shades[alpha]) == gx_no_color_index )
  578.               {    /* Map the color now. */
  579. #define make_shade(v, alpha)\
  580.   (gx_max_color_value -\
  581.    ((gx_max_color_value - (v)) * (alpha) / 15))
  582.                 gx_color_value r = make_shade(rgb[0], alpha);
  583.                 gx_color_value g = make_shade(rgb[1], alpha);
  584.                 gx_color_value b = make_shade(rgb[2], alpha);
  585. #undef make_shade
  586.                 a_color = (*dev_proc(tdev, map_rgb_color))(tdev, r, g, b);
  587.                 if ( a_color != gx_no_color_index )
  588.                   {    shades[alpha] = a_color;
  589.                     break;
  590.                   }
  591.                 /* Try a higher saturation.  (We know */
  592.                 /* the fully saturated color exists.) */
  593.                 alpha += (16 - alpha) >> 1;
  594.               }
  595.             if ( a_color != prev_color )
  596.               { if ( prev_color != gx_no_color_index )
  597.                   (*dev_proc(tdev, fill_rectangle))(tdev,
  598.                     prev_x, yi, xi - prev_x, 1,
  599.                     prev_color);
  600.                 prev_x = xi;
  601.                 prev_color = a_color;
  602.               }
  603.           }
  604.         if ( prev_color != gx_no_color_index )
  605.           (*dev_proc(tdev, fill_rectangle))(tdev,
  606.                     prev_x, yi, x + w - prev_x, 1,
  607.                     prev_color);
  608.       }
  609.     return 0;
  610. }
  611.